package com.ruoyi.basedata.service.impl;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.github.pagehelper.PageInfo;
import com.ruoyi.basedata.domain.GoodsType;
import com.ruoyi.basedata.mapper.GoodsMapper;
import com.ruoyi.basedata.mapper.GoodsTypeMapper;
import com.ruoyi.basedata.service.IGoodsTypeService;
import com.ruoyi.common.core.constant.HttpStatus;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.basedata.Goods;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

import static com.ruoyi.common.core.utils.PageUtils.startPage;

/**
 * 商品类别Service业务层处理
 *
 * @author wl
 * @date 2024-10-25
 */
@Service
@Slf4j
public class GoodsTypeServiceImpl implements IGoodsTypeService {
    @Autowired
    private GoodsTypeMapper goodsTypeMapper;

    @Autowired
    private GoodsMapper goodsMapper;

    /**
     * 查询商品类别
     *
     * @param id 商品类别主键
     * @return 商品类别
     */
    @Override
    public GoodsType selectGoodsTypeById(Integer id) {
        return goodsTypeMapper.selectGoodsTypeById(id);
    }

    /**
     * 查询商品类别列表
     *
     * @param goodsType 商品类别
     * @return 商品类别
     */
    public TableDataInfo selectGoodsTypeList(GoodsType goodsType) {
        if (StringUtils.isBlank(goodsType.getTypeName()) && StringUtils.isBlank(goodsType.getTypeCode())) {
            goodsType.setParentId(0);
        }
        // 设置分页，仅分页指定的分类，不包括其子分类
        startPage();

        // 查询指定的分类
        List<GoodsType> mainGoodsTypeList = goodsTypeMapper.selectGoodsTypeList(goodsType);
        // 获取分页后的总数
        long total = new PageInfo<>(mainGoodsTypeList).getTotal();

        // 准备最终返回的分类列表
        List<GoodsType> resultGoodsTypeList = new ArrayList<>();

        // 遍历主分类列表，获取每个分类及其所有子分类
        for (GoodsType type : mainGoodsTypeList) {
            // 递归获取子级分类
            List<GoodsType> children = getGoodsTypeChildrenList(type.getId());
            // 设置子级分类
            type.setChildren(children);
            // 添加主分类
            resultGoodsTypeList.add(type);
        }

        // 构建 TableDataInfo 对象，用于返回分页数据
        TableDataInfo tableDataInfo = new TableDataInfo();
        tableDataInfo.setTotal(total);
        tableDataInfo.setRows(resultGoodsTypeList);
        tableDataInfo.setCode(HttpStatus.SUCCESS);
        tableDataInfo.setMsg("查询成功");

        return tableDataInfo;
    }

    /**
     * 从数据库中获取指定分类的所有子分类
     */
    public List<GoodsType> getGoodsTypeChildrenList(Integer parentId) {
        List<GoodsType> res = new ArrayList<>();
        // 查询直接子分类
        GoodsType goodsType = new GoodsType();
        goodsType.setParentId(parentId);
        List<GoodsType> childrenList = goodsTypeMapper.selectGoodsTypeList(goodsType);
        if (childrenList != null && !childrenList.isEmpty()) {
            for (GoodsType type : childrenList) {
                // 递归获取子分类的子分类
                List<GoodsType> subChildren = getGoodsTypeChildrenList(type.getId());
                // 设置当前分类的子分类
                type.setChildren(subChildren);
                res.add(type);
            }
        }
        return res;
    }


    /**
     * 新增商品类别
     *
     * @param goodsType 商品类别
     * @return 结果
     */
    @Override
    public AjaxResult insertGoodsType(GoodsType goodsType) {
        if (StringUtils.isBlank(goodsType.getTypeName())) {
            return AjaxResult.error("分类名称不能为空");
        }
        //商品分类编码校验重复
        if (goodsTypeMapper.getGoodsTypeCountByCode(goodsType.getTypeCode()) > 0) {
            return AjaxResult.error("分类编码已存在");
        }
        if (StringUtils.isBlank(goodsType.getTypeCode())) {
            return AjaxResult.error("分类编码不能为空");
        }
        if (goodsType.getParentId() == null) {
            goodsType.setParentId(0);
        }
        //获取当前登录用户
        goodsType.setCreateBy(SecurityUtils.getUsername());
        goodsType.setCreateDate(new Date());
        int addNum = goodsTypeMapper.insertGoodsType(goodsType);
        log.info("WarehouseGoodsTypeServiceImpl addGoodsType goodsType: {} addNum:{}", goodsType, addNum);
        if (addNum > 0) {
            return AjaxResult.success();
        }
        return AjaxResult.error("添加失败");
    }

    /**
     * 修改商品类别
     *
     * @param goodsType 商品类别
     * @return 结果
     */
    @Override
    public AjaxResult updateGoodsType(GoodsType goodsType) {
        if (goodsType.getId() == null) {
            return AjaxResult.error("商品id不能为空");
        }
        if (StringUtils.isBlank(goodsType.getTypeName())) {
            return AjaxResult.error("分类名称不能为空");
        }
        //获取当前登录用户
        goodsType.setModifyDate(new Date());
        goodsType.setModifyBy(SecurityUtils.getUsername());
        int updNum = goodsTypeMapper.updateGoodsType(goodsType);
        log.info("WarehouseGoodsTypeServiceImpl updateGoodsType goodsType: {} updNum:{}", goodsType, updNum);
        if (updNum > 0) {
            return AjaxResult.success();
        }
        return AjaxResult.error("更新失败");
    }

    /**
     * 批量删除商品类别
     *
     * @param ids 需要删除的商品类别主键
     * @return 结果
     */
    @Override
    public AjaxResult deleteGoodsTypeByIds(Integer[] ids) {
        //分类下面有商品就不嫩删除
        int goodsCount = goodsMapper.selectGoodsCountListByTypeIds(ids);
        if (goodsCount > 0) {
            return AjaxResult.error("分类下有商品，不能删除");
        }
        //分类下还有分类不能删除
        int typeCount = goodsTypeMapper.selectGoodsTypeCountByParentIds(ids);
        if (typeCount > 0) {
            return AjaxResult.error("分类下还有分类，不能删除");
        }
        int delNum = goodsTypeMapper.deleteGoodsTypeByIds(ids);
        log.info("WarehouseGoodsTypeServiceImpl deleteGoodsTypeById ids: {} delNum:{}", ids, delNum);
        if (delNum > 0) {
            return AjaxResult.success();
        }
        return AjaxResult.error("删除失败");
    }

    /**
     * 删除商品类别信息
     *
     * @param id 商品类别主键
     * @return 结果
     */
    @Override
    public AjaxResult deleteGoodsTypeById(Integer id) {
        //分类下面有商品就不嫩删除
        List<Goods> goodsList = goodsMapper.selectGoodsListByTypeIds(Collections.singletonList(id));
        if (goodsList != null && !goodsList.isEmpty()) {
            return AjaxResult.error("分类下有商品，不能删除");
        }
        int delNum = goodsTypeMapper.deleteGoodsTypeById(id);
        log.info("WarehouseGoodsTypeServiceImpl deleteGoodsTypeById id: {} delNum:{}", id, delNum);
        if (delNum > 0) {
            return AjaxResult.success();
        }
        return AjaxResult.error("删除失败");
    }

    /**
     * @return com.finer.entity.ResponseMessage
     * @description 校验商品分类编码是否存在
     * @date 2024/10/23 下午3:37
     * @Param typeCode:
     **/
    public AjaxResult checkGoodsTypeCode(String typeCode) {
        //分类编号不能为空
        if (StringUtils.isBlank(typeCode)) {
            return AjaxResult.error("500", "商品分类编码不能为空");
        }

        //根据分类编号获取分类编码数量
        int count = goodsTypeMapper.getGoodsTypeCountByCode(typeCode);
        log.info("WarehouseGoodsTypeServiceImpl checkGoodsTypeCode typeCode: {} count:{}", typeCode, count);

        //如果数量大于0，则说明分类编码已存在
        if (count > 0) {
            return AjaxResult.error("商品分类编码已存在,请重新刷新!");
        }
        return AjaxResult.success();
    }

    /**
     * @return com.ruoyi.common.core.web.domain.AjaxResult
     * @description 获取所有商品分类
     * @date 2024/10/25 上午11:49
     **/
    public AjaxResult selectGoodsTypeAllList() {
        List<GoodsType> goodsTypeList = goodsTypeMapper.selectGoodsTypeAllList();
        log.info("WarehouseGoodsTypeServiceImpl selectGoodsTypeAllList goodsTypeList: {}", goodsTypeList);
        return AjaxResult.success(goodsTypeList);
    }


    /**
     * @return java.util.List<com.finer.entity.document.FinerGoodsType>
     * @description 从数据库中获取子分类
     * @date 2024/10/23 上午10:25
     * @Param parentId:
     **/
    public List<GoodsType> getGoodsTypeChilrenList(Integer parentId) {
        List<GoodsType> res = new ArrayList<>();
        List<GoodsType> childrenList = new ArrayList<>();
        GoodsType goodsType = new GoodsType();
        goodsType.setParentId(parentId);
        childrenList = goodsTypeMapper.selectGoodsTypeList(goodsType);
        if (childrenList != null && !childrenList.isEmpty()) {
            res.addAll(childrenList);
            for (GoodsType type : childrenList) {
                res.addAll(getGoodsTypeChilrenList(type.getId()));
            }
        }
        return res;
    }


    /**
     * @return java.util.List<com.finer.entity.document.FinerGoodsType>
     * @description 递归获取子分类
     * @date 2024/10/23 上午10:26
     * @Param parentId:
     * @Param goodsTypeList:
     **/
    public List<GoodsType> getChildrenList(Integer parentId, List<GoodsType> goodsTypeList) {
        List<GoodsType> childrenList = goodsTypeList
                .stream()
                .filter(goodsType -> {
                    return Objects.equals(goodsType.getParentId(), parentId);
                })
                .map(goodsType -> {
                    goodsType.setChildren(getChildrenList(goodsType.getId(), goodsTypeList));
                    return goodsType;
                })
                .collect(Collectors.toList());
        log.info("childrenList: {}", childrenList);
        return childrenList;
    }
}
